//#include<iostream>
//#include<cstring>
//class mystring {
//
//private:
//	char* data;
//public:
//	mystring()
//		:data(new char[1])
//	{
//		data[0] = '\0';
//	
//	}
//	mystring(const mystring& other)
//	{
//		data = new char[strlen(other.data) + 1];
//		strcpy(data, other.data);
//	
//	
//	
//	}
//	~mystring() {
//	
//		delete[]data;
//	
//	
//	}
//	mystring& operator=(const mystring& other)
//	{
//		if (this != &other)
//		{
//			delete[]data;
//			data=new char[strlen(other.data) + 1];
//			strcpy(data, other.data);
//
//		
//		
//		
//		}
//	
//		return *this;
//	
//	}
//
//};
#include<iostream>
#include<string>
#include<unordered_map>
using namespace std;
int main()
{
	string str;
	cin >> str;
	unordered_map<int, int>st;
	for (auto e : str)
	{
		st[e]++;


	}
	for (int i = 0; i < str.size(); i++)
	{
		if (st[str[i]] == 1)
		{
			cout << str[i] << " ";
			return 0;
		}


	}




}
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	vector<vector<int>>result;
	vector<vector<int>> levelOrder(TreeNode* root) {
		queue<TreeNode*>st;
		if (root != nullptr)
		{
			st.push(root);
		}
		while (st.size())
		{
			int sz = st.size();
			vector<int>path;
			while (sz--)
			{
				TreeNode* find = st.front();
				st.pop();
				path.push_back(find->val);
				if (find->left)
				{
					st.push(find->left);
				}
				if (find->right)
				{
					st.push(find->right);
				}
			}
			result.push_back(path);


		}

		return result;

	}
}; class Solution {
public:
	int dx[4] = { 0,0,1,-1 };
	int dy[4] = { 1,-1,0,0 };
	typedef pair<int, int> pll;
	int orangesRotting(vector<vector<int>>& grid) {
		int m = grid.size();
		int n = grid[0].size();
		int count = 0;
		queue<pll>st;
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (grid[i][j] == 1)
					count++;
				else if (grid[i][j] == 2)
				{
					grid[i][j] = -1;
					st.push({ i,j });
				}

			}
		}

		if (count == 0)return 0;
		int min = 0;
		while (st.size())
		{

			min++;
			int sz = st.size();
			for (int i = 0; i < sz; i++)
			{
				auto [a, b] = st.front();
				st.pop();
				for (int k = 0; k < 4; k++)
				{
					int x = a + dx[k];
					int y = b + dy[k];
					if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1)
					{
						count--;
						if (count == 0)return min;
						grid[x][y] = -1;
						st.push({ x,y });

					}

				}

			}


		}


		return count > 0 ? -1 : min;




	}
}; class Solution {
public:
	int climbStairs(int n) {
		if (n == 1)return 1;
		vector<int>dp(n + 1);
		dp[0] = 0;
		dp[1] = 1;
		dp[2] = 2;
		if (n <= 2)
			return dp[n];
		for (int i = 3; i <= n; i++)
		{

			dp[i] = dp[i - 1] + dp[i - 2];

		}

		return dp[n];












	}
}; class Solution {
public:
	int lengthOfLIS(vector<int>& nums) {
		int m = nums.size();
		vector<int>dp(m, 1);
		int maxp = 1;
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j <= i; j++)
			{
				if (nums[i] > nums[j])
				{


					dp[i] = max(dp[i], dp[j] + 1);
					maxp = max(maxp, dp[i]);


				}

			}
		}




		return maxp;



	}
}; class Solution {
public:
	int uniquePaths(int m, int n) {
		vector<vector<int>>dp(m, vector<int>(n));
		for (int i = 0; i < n; i++)
		{

			dp[0][i] = 1;


		}
		for (int i = 0; i < m; i++)
		{

			dp[i][0] = 1;


		}


		for (int i = 1; i < m; i++)
			for (int j = 1; j < n; j++)
			{
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}


		return dp[m - 1][n - 1];




	}
}; class Solution {
public:
	int majorityElement(vector<int>& nums) {
		sort(nums.begin(), nums.end());
		return nums[nums.size() / 2];
	}
}; class Solution {
public:
	int singleNumber(vector<int>& nums) {
		int sum = nums[0];
		for (int i = 1; i < nums.size(); i++)
		{
			sum ^= nums[i];
		}
		return sum;








	}
}; class Solution {
public:
	int maxProfit(vector<int>& prices) {
		int minp = INT_MAX;
		int maxcot = 0;
		for (int i = 0; i < prices.size() - 1; i++)
		{
			minp = min(minp, prices[i]);
			maxcot = max(maxcot, prices[i + 1] - minp);

		}
		return maxcot;
	}
};/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
	ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
		ListNode* cur1 = headA;
		ListNode* cur2 = headB;
		if (headA == nullptr || headB == nullptr)
			return nullptr;
		int count1 = 0;
		int count2 = 0;
		while (cur1->next)
		{
			cur1 = cur1->next;
			count1++;
		}
		while (cur2->next)
		{
			cur2 = cur2->next;
			count2++;
		}
		if (cur1 != cur2)return nullptr;

		ListNode* longlist = headA;
		ListNode* shortlist = headB;
		if (count2 > count1)
		{
			longlist = headB;
			shortlist = headA;
		}
		cur1 = longlist;
		cur2 = shortlist;
		int cnt = abs(count2 - count1);
		while (cnt)
		{
			cur1 = cur1->next;
			cnt--;
		}

		while (cur1 != cur2)
		{

			cur1 = cur1->next;
			cur2 = cur2->next;


		}


		return cur1;

















	}
}; class Solution {
public:
	int myAtoi(string s) {

		char* ptr = &s[0];
		int more = 0;
		while (*ptr == ' ')
		{
			ptr++;
		}
		int flag = 1;
		if (*ptr == '+')
		{
			ptr++; more++;
		}
		if (*ptr == '-')
		{
			flag = -1; ptr++; more++;
		}
		long long sum = 0;
		if (more > 1)return 0;
		while (*ptr != '\0')
		{
			if (*ptr >= '0' && *ptr <= '9')
			{
				sum = sum * 10 + *ptr - '0';
				if (sum * flag > INT_MAX)return INT_MAX;
				if (sum * flag < INT_MIN)return INT_MIN;


			}
			else
			{
				if (flag == 1)return sum;
				else return -1 * sum;
			}
			ptr++;

		}
		sum = sum * flag;






		return sum;


	}
};/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 class Solution {
 public:
	 int kthToLast(ListNode* head, int k) {
		 ListNode* fast = head;
		 ListNode* slow = head;
		 while (k--)
		 {
			 fast = fast->next;

		 }
		 while (fast)
		 {
			 fast = fast->next;
			 slow = slow->next;


		 }
		 return slow->val;
	 }
 };